import proyecto
import unittest

import managers.proyectos_mgr
import managers.usuarios_mgr
import managers.desarrollo_mgr
import managers.fases_mgr
import managers.tipositem_mgr
import managers.items_mgr
import managers.lineabase_mgr
import managers.solicitud_mgr

from proyecto import *

class ProyectoTestCase(unittest.TestCase):

    def setUp(self):
        self.app = proyecto.app.test_client()

    def test_login(self):
        rv = self.app.post('/login', data={
            'username':'admin',
            'password':'admin',
        }, follow_redirects=True)
        assert 'Login Incorrecto' not in rv.data

        rv = self.app.post('/login', data={
            'username':'asdf',
            'password':'asdf',
        }, follow_redirects=True)
        assert 'El usuario no existe' in rv.data

        rv = self.app.post('/login', data={
            'username':'admin',
            'password':'asdf',
        }, follow_redirects=True)
        assert 'La contrasena no es correcta' in rv.data

    def test_listar_usuarios(self):
        rv = managers.usuarios_mgr.listar_usuarios()
        assert rv != None

    def test_buscar_usuarios(self):
        rv = managers.usuarios_mgr.buscar_usuarios('admin', 'usuario')
        assert rv != None

    def test_verificar_contrasena(self):
        id_usuario = 'admin'
        pass_anterior = ''
        pass_nuevo = ''
        pass_confirmacion = ''
        rv = managers.usuarios_mgr.verificar_contrasena(id_usuario, \
        pass_anterior, pass_nuevo, pass_confirmacion)
        assert 'Datos requeridos no ingresados' == rv

        id_usuario = 'admin'
        pass_anterior = 'asdf'
        pass_nuevo = 'admin'
        pass_confirmacion = 'admin'
        rv = managers.usuarios_mgr.verificar_contrasena(id_usuario, \
        pass_anterior, pass_nuevo, pass_confirmacion)
        assert 'La contrasena anterior no es correcta' == rv

        id_usuario = 'admin'
        pass_anterior = 'admin'
        pass_nuevo = 'asdf'
        pass_confirmacion = 'fdsa'
        rv = managers.usuarios_mgr.verificar_contrasena(id_usuario, \
        pass_anterior, pass_nuevo, pass_confirmacion)
        assert 'La contrasena nueva no verifica' == rv

    def verificar_parametros_usuario(self):
        id_usuario = ''
        nombre = ''
        apellido = ''
        contrasena = ''
        contrasena2 = ''
        rv = managers.usuarios_mgr.verificar_parametros_usuario\
        (id_usuario, nombre, apellido, contrasena, contrasena2)
        assert True == rv

    def test_insertar_usuario(self):
        id_usr_creador = 'admin'
        id_usuario = 'admin'
        nombre = 'admin'
        apellido = 'admin'
        correo = ''
        contrasena = 'admin'
        tipo = 1
        rv = managers.usuarios_mgr.insertar_usuario(id_usr_creador, \
        id_usuario, nombre, apellido, correo, contrasena, tipo)
        assert 'El usuario ya existe' == rv

    def test_verificar_parametros_modificar_usuario(self):
        id_usuario = 'id_usuario'
        nombre = 'nombre'
        apellido = 'apellido'
        rv = managers.usuarios_mgr.verificar_parametros_modificar_usuario\
        (id_usuario, nombre, apellido)
        assert False == rv

        id_usuario = ''
        nombre = ''
        apellido = ''
        rv = managers.usuarios_mgr.verificar_parametros_modificar_usuario\
        (id_usuario, nombre, apellido)
        assert True == rv

    def test_validaciones_eliminar_usuario(self):
        seleccionados = []
        rv = managers.usuarios_mgr.validaciones_eliminar_usuario\
        (seleccionados)
        assert "Debe seleccionar al menos usuario" == rv

    def test_validaciones_activar_usuario(self):
        seleccionados = []
        rv = managers.usuarios_mgr.validaciones_activar_usuario\
        (seleccionados)
        assert "Debe seleccionar al menos usuario" == rv
        
    def test_listar_proyectos(self):
        id_usuario = "lider"
        rv = managers.proyectos_mgr.listar_proyectos(id_usuario)
        assert rv != None
        
    def test_verificar_parametros_crear_proyecto(self):
        nombre = 'nombre'
        descripcion = 'descripcion'
        presupuesto = 'presupuesto'
        rv = managers.proyectos_mgr.verificar_parametros_crear_proyecto\
        (nombre, descripcion, presupuesto)
        assert True == rv

        nombre = ''
        descripcion = ''
        presupuesto = ''
        rv = managers.proyectos_mgr.verificar_parametros_crear_proyecto\
        (nombre, descripcion, presupuesto)
        assert False == rv

    def test_verificar_valor_presupuesto(self):
        presupuesto = ''
        rv = managers.proyectos_mgr.verificar_valor_presupuesto\
        (presupuesto)
        assert False == rv

        presupuesto = 'asdf'
        rv = managers.proyectos_mgr.verificar_valor_presupuesto\
        (presupuesto)
        assert False == rv

        presupuesto = '10'
        rv = managers.proyectos_mgr.verificar_valor_presupuesto\
        (presupuesto)
        assert True == rv

    def test_validaciones_administrar_miembros(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_administrar_miembros\
        (seleccionados)
        assert "Debe seleccionar un proyecto" == rv
        
        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.proyectos_mgr.validaciones_administrar_miembros\
        (seleccionados)
        assert "Debe seleccionar un unico proyecto" == rv     
        
    def test_validaciones_modificar_proyecto(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_modificar_proyecto\
        (seleccionados)
        assert "Debe seleccionar un proyecto" == rv
        
        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.proyectos_mgr.validaciones_modificar_proyecto\
        (seleccionados)
        assert "Debe seleccionar un unico proyecto" == rv
    
    def test_validaciones_cancelar_proyecto(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_cancelar_proyecto\
        (seleccionados)
        assert "Debe seleccionar un proyecto" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.proyectos_mgr.validaciones_cancelar_proyecto\
        (seleccionados)
        assert "Debe seleccionar un unico proyecto" == rv

    def test_validaciones_desasignar_miembro(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_desasignar_miembro\
        (seleccionados)
        assert "Debe seleccionar un usuario" == rv
        
    def test_validaciones_administrar_fase(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_administrar_fase\
        (seleccionados)
        assert "Debe seleccionar un proyecto" == rv
        
        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.proyectos_mgr.validaciones_administrar_fase\
        (seleccionados)
        assert "Debe seleccionar un unico proyecto" == rv
        
    def test_validaciones_administrar_roles(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_administrar_roles\
        (seleccionados)
        assert "Debe seleccionar un proyecto" == rv
        
        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.proyectos_mgr.validaciones_administrar_roles\
        (seleccionados)
        assert "Debe seleccionar un unico proyecto" == rv

    def test_validaciones_asignar_miembro(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_asignar_miembro\
        (seleccionados)
        assert "Debe seleccionar al menos un usuario" == rv

    def test_validaciones_render_asignar_roles(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_render_asignar_roles\
        (seleccionados)
        assert "Debe seleccionar un usuario" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.proyectos_mgr.validaciones_render_asignar_roles\
        (seleccionados)
        assert "Debe seleccionar un unico usuario" == rv
        
    def test_validaciones_modificar_rol(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_modificar_rol\
        (seleccionados)
        assert "Debe seleccionar un rol" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.proyectos_mgr.validaciones_modificar_rol\
        (seleccionados)
        assert "Debe seleccionar un solo rol" == rv
        
    def test_verificar_parametros_desarrollo_fases(self):
        seleccionados = []
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_fases(seleccionados)
        assert "Debe seleccionar un proyecto" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_fases(seleccionados)
        assert "Debe seleccionar un solo proyecto" == rv
        
    def test_verificar_parametros_desarrollo_tipoitem(self):
        seleccionados = []
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_tipoitem(seleccionados)
        assert "Debe seleccionar una fase" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_tipoitem(seleccionados)
        assert "Debe seleccionar una sola fase" == rv
        
    def test_validaciones_modificar_fase(self):
        seleccionados = []
        rv = managers.fases_mgr.\
        validaciones_modificar_fase(seleccionados)
        assert "Debe seleccionar una fase" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.fases_mgr.\
        validaciones_modificar_fase(seleccionados)
        assert "Debe seleccionar una sola fase" == rv
        
    def test_verificar_parametros_desarrollo_item(self):
        seleccionados = []
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_item(seleccionados)
        assert "Debe seleccionar una fase" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_item(seleccionados)
        assert "Debe seleccionar una sola fase" == rv

    def test_validaciones_asignar_roles(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_asignar_roles\
        (seleccionados)
        assert "Debe seleccionar al menos un rol" == rv

    def test_validaciones_iniciar_proyecto(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_iniciar_proyecto\
        (seleccionados)
        assert "Debe seleccionar un proyecto" == rv

    def test_validaciones_finalizar_proyecto(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_finalizar_proyecto\
        (seleccionados)
        assert "Debe seleccionar un proyecto" == rv

    def test_validaciones_eliminar_roles(self):
        seleccionados = []
        rv = managers.proyectos_mgr.validaciones_eliminar_roles\
        (seleccionados)
        assert "Debe seleccionar al menos un rol" == rv
        
    def test_listar_fases(self):
        nombre_proyecto = 'p1'
        rv = managers.fases_mgr.listar_fases(nombre_proyecto)
        assert rv != None
        
    def test_verificar_parametros_crear_rol(self):
        nombre = ''
        descripcion = ''
        permisos = []
        rv = managers.proyectos_mgr.verificar_parametros_crear_rol(\
        nombre, descripcion, permisos)

        assert rv == "Se debe ingresar un nombre"

        nombre = 'nombre'

        rv = managers.proyectos_mgr.verificar_parametros_crear_rol(\
        nombre, descripcion, permisos)

        assert rv == "Se debe ingresar una descripcion"

        descripcion = 'descripcion'

        rv = managers.proyectos_mgr.verificar_parametros_crear_rol(\
        nombre, descripcion, permisos)

        assert rv == "Debe seleccionar al menos un permiso"

    def test_verificar_parametros_modificar_rol(self):
        nombre = ''
        descripcion = ''
        permisos = []
        rv = managers.proyectos_mgr.verificar_parametros_modificar_rol(\
        nombre, descripcion, permisos)

        assert rv == "Se debe ingresar un nombre"

        nombre = 'nombre'

        rv = managers.proyectos_mgr.verificar_parametros_modificar_rol(\
        nombre, descripcion, permisos)

        assert rv == "Se debe ingresar una descripcion"

        descripcion = 'descripcion'

        rv = managers.proyectos_mgr.verificar_parametros_modificar_rol(\
        nombre, descripcion, permisos)

        assert rv == "Debe seleccionar al menos un permiso"

    def test_validaciones_importar_fase(self):
        seleccionados = []
        rv = managers.fases_mgr.validaciones_importar_fase(seleccionados)

        assert rv == "Debe seleccionar al menos una fase"
        
    def test_validaciones_parametros_agregar_atributos(self):
        nombreatributo = ''
        descripcionatributo = ''
        tipoatributo = ''
        longitudatributo = ''
        precisionatributo = ''
        items = []
        rv = managers.tipositem_mgr.\
        validaciones_parametros_agregar_atributos(nombreatributo,\
        descripcionatributo, tipoatributo, longitudatributo,\
        precisionatributo, items)
        assert rv == "Se debe ingresar un nombre para el atributo"
        
    def test_validaciones_eliminar_atributos(self):
        seleccionados = []
        rv = managers.tipositem_mgr.validaciones_eliminar_atributos(\
        seleccionados)
        assert rv == "Debe seleccionar un atributo"
        
    def test_validaciones_parametros_crear_tipositem(self):
        nombre_proyecto = 'p1'
        nombre_fase = "f1"
        nombre = ''
        descripcion = ''
        nombreatributo= ''
        descripcionatributo = ''
        observacionatributo = ''
        items = []
        rv = managers.tipositem_mgr.\
        validaciones_parametros_crear_tipositem(nombre_proyecto, \
        nombre_fase, nombre, descripcion, nombreatributo, \
        descripcionatributo, observacionatributo, items)
        assert rv == "Se debe ingresar un nombre para el tipo item"
    
    def test_validaciones_eliminar_tipoitem(self):
        id_usuario = "lider"
        nombre_proyecto = 'p1'
        nombre_fase = "f1"
        seleccionados = []
        rv = managers.tipositem_mgr.validaciones_eliminar_tipoitem(\
        id_usuario, nombre_proyecto, nombre_fase, seleccionados)
                                    
        assert rv == "Debe seleccionar un tipo item"
        
    def test_validaciones_modificar_tipoitem(self):
        seleccionados = []
        nombre_proyecto = 'p1'
        nombre_fase = "f1"
        rv = managers.tipositem_mgr.validaciones_modificar_tipoitem(\
        seleccionados, nombre_proyecto, nombre_fase)
            
        assert rv == "Debe seleccionar un tipo item"
    
    def test_validaciones_parametros_modificar_tipositem(self):
        nombre_proyecto = "p1"
        nombre_fase = "f1"
        nombre_tipoitem = "t1"
        nombre = ""
        descripcion = ""
        nombreatributo= ""
        descripcionatributo = ""
        observacionatributo = ""
        items = []
        rv = managers.tipositem_mgr.\
        validaciones_parametros_modificar_tipositem(nombre_proyecto, \
        nombre_fase, nombre_tipoitem, nombre, descripcion, 
        nombreatributo, descripcionatributo, observacionatributo, items)
        
        assert rv == "Se debe ingresar un nombre para el tipo item"

    def test_validacion_aprobar_item(self):
        nombre_proyecto = 'p1'
        nombre_fase = "f1"
        seleccionados = []
        rv = managers.items_mgr.\
        validacion_aprobar_item(seleccionados, nombre_fase,\
        nombre_proyecto)
        assert "Debe seleccionar al menos un item" == rv
        
    def test_validacion_estado_revision(self):
        seleccionados = []
        nombre_fase = 'f1'
        nombre_proyecto = 'p1'
        rv = managers.items_mgr.\
        validacion_aprobar_item(seleccionados, nombre_fase,\
        nombre_proyecto)
        assert "Debe seleccionar al menos un item" == rv

    def test_validaciones_boton_eliminar_solicitud(self):
        seleccionados = []
        id_usuario = 1
        rv = managers.solicitud_mgr.\
        validaciones_boton_eliminar_solicitud(seleccionados, id_usuario)
        assert "Debe seleccionar una solicitud" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.solicitud_mgr.\
        validaciones_boton_eliminar_solicitud(seleccionados, id_usuario)
        assert "Debe seleccionar una unica solicitud" == rv

    def test_validaciones_boton_enviar_solicitud(self):
        seleccionados = []
        id_usuario = 1
        nombre_proyecto = 'p1'
        rv = managers.solicitud_mgr.\
        validaciones_boton_enviar_solicitud(seleccionados, id_usuario, \
        nombre_proyecto)
        assert "Debe seleccionar al menos una solicitud" == rv
        
    def test_verificar_parametros_desarrollo_solicitud(self):
        seleccionados = []
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_solicitud(seleccionados)
        assert "Debe seleccionar un proyecto" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_solicitud(seleccionados)
        assert "Debe seleccionar un unico proyecto" == rv
        
    def test_verificar_parametros_ver_linea_base(self):
        seleccionados = []
        rv = managers.desarrollo_mgr.\
        verificar_parametros_ver_linea_base(seleccionados)
        assert "Debe seleccionar una linea base" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.desarrollo_mgr.\
        verificar_parametros_ver_linea_base(seleccionados)
        assert "Debe seleccionar una unica linea base" == rv
    
    def test_verificar_seleccionado_eliminar_item(self):
        seleccionados = []
        rv = managers.items_mgr.\
        verificar_seleccionado_eliminar_item(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.items_mgr.\
        verificar_seleccionado_eliminar_item(seleccionados)
        assert "Debe seleccionar un unico item" == rv
    
    def test_validar_seleccionados_eliminar_relacion(self):
        seleccionados = []
        rv = managers.items_mgr.\
        validar_seleccionados_eliminar_relacion(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.items_mgr.\
        validar_seleccionados_eliminar_relacion(seleccionados)
        assert "Debe seleccionar un unico item" == rv
        
    def test_validar_eliminacion_relacion(self):
        seleccionados = []
        rv = managers.items_mgr.\
        validar_seleccionados_eliminar_relacion(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.items_mgr.\
        validar_seleccionados_eliminar_relacion(seleccionados)
        assert "Debe seleccionar un unico item" == rv
        
    def test_validacion_seleccionados_revertir_item(self):
        seleccionados = []
        rv = managers.items_mgr.\
        validar_seleccionados_eliminar_relacion(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.items_mgr.\
        validar_seleccionados_eliminar_relacion(seleccionados)
        assert "Debe seleccionar un unico item" == rv
        
    def test_verificar_parametros_ver_relaciones(self):
        seleccionados = []
        rv = managers.items_mgr.\
        verificar_parametros_ver_relaciones(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.items_mgr.\
        verificar_parametros_ver_relaciones(seleccionados)
        assert "Debe seleccionar un unico item" == rv
        
    def test_verificar_parametros_desarrollo_linea_base(self):
        seleccionados = []
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_linea_base(seleccionados)
        assert "Debe seleccionar una fase" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.desarrollo_mgr.\
        verificar_parametros_desarrollo_linea_base(seleccionados)
        assert "Debe seleccionar una sola fase" == rv
        
    def test_validaciones_finalizar_fase(self):
        seleccionados = []
        nombre_proyecto = 'p1'
        rv = managers.fases_mgr.\
        validaciones_finalizar_fase(nombre_proyecto, seleccionados)
        assert "Debe seleccionar una fase" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.fases_mgr.\
        validaciones_finalizar_fase(nombre_proyecto, seleccionados)
        assert "Debe seleccionar una sola fase" == rv
        
    def test_verificar_parametros_modificar_item(self):
        seleccionados = []
        rv = managers.items_mgr.\
        verificar_parametros_modificar_item(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.items_mgr.\
        verificar_parametros_modificar_item(seleccionados)
        assert "Debe seleccionar un unico item" == rv
        
    def test_validaciones_revivir_item(self):
        seleccionados = []
        rv = managers.items_mgr.validaciones_revivir_item(seleccionados)
        assert "Debe seleccionar al menos un item" == rv
        
    def test_verificar_parametros_activar_item(self):
        seleccionados = []
        rv = managers.items_mgr.\
        verificar_parametros_activar_item(seleccionados)
        assert "Debe seleccionar al menos un item" == rv
        
    def test_validacion_estado_finalizado(self):
        seleccionados = []
        rv = managers.items_mgr.\
        validacion_estado_finalizado(seleccionados)
        assert "Debe seleccionar al menos un item" == rv
        
    def test_verificar_parametros_boton_subirarchivo(self):
        seleccionados = []
        rv = managers.items_mgr.\
        verificar_parametros_boton_subirarchivo(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.items_mgr.\
        verificar_parametros_boton_subirarchivo(seleccionados)
        assert "Debe seleccionar un unico item" == rv
        
    def test_verificar_parametros_boton_descargararchivo(self):
        seleccionados = []
        rv = managers.items_mgr.\
        verificar_parametros_boton_descargararchivo(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.items_mgr.\
        verificar_parametros_boton_descargararchivo(seleccionados)
        assert "Debe seleccionar un unico item" == rv
    
    def test_validaciones_boton_romper_lineabase(self):
        seleccionados = []
        rv = managers.lineabase_mgr.\
        validaciones_boton_romper_lineabase(seleccionados)
        assert "Debe seleccionar una linea base" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.lineabase_mgr.\
        validaciones_boton_romper_lineabase(seleccionados)
        assert "Debe seleccionar solamente una linea base" == rv
        
    def test_verificar_parametros_calculo_impacto(self):
        seleccionados = []
        rv = managers.solicitud_mgr.\
        verificar_parametros_calculo_impacto(seleccionados)
        assert "Debe seleccionar un item" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.solicitud_mgr.\
        verificar_parametros_calculo_impacto(seleccionados)
        assert "Debe seleccionar un unico item" == rv
        
    def test_verificar_crear_solicitud(self):
        seleccionados = []
        descripcion = ""
        rv = managers.solicitud_mgr.\
        verificar_crear_solicitud(descripcion, seleccionados)
        assert "Debe ingresar una descripcion" == rv
        
    def test_validaciones_boton_modificar_solicitud(self):
        seleccionados = []
        id_usuario = 'id_usuario'
        rv = managers.solicitud_mgr.\
        validaciones_boton_modificar_solicitud(seleccionados, id_usuario)
        assert "Debe seleccionar una solicitud" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.solicitud_mgr.\
        validaciones_boton_modificar_solicitud(seleccionados, id_usuario)
        assert "Debe seleccionar una unica solicitud" == rv
    
    def test_verificar_modificar_solicitud(self):
        seleccionados = []
        descripcion = ""
        rv = managers.solicitud_mgr.\
        verificar_crear_solicitud(descripcion, seleccionados)
        assert "Debe ingresar una descripcion" == rv
     
    def test_validaciones_boton_ver_solicitud(self):
        seleccionados = []
        rv = managers.solicitud_mgr.\
        validaciones_boton_ver_solicitud(seleccionados)
        assert "Debe seleccionar una solicitud" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.solicitud_mgr.\
        validaciones_boton_ver_solicitud(seleccionados)
        assert "Debe seleccionar una unica solicitud" == rv   
        
    def test_validaciones_administrar_comite(self):
        seleccionados = []
        rv = managers.solicitud_mgr.\
        validaciones_administrar_comite(seleccionados)
        assert "Debe seleccionar un proyecto" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.solicitud_mgr.\
        validaciones_administrar_comite(seleccionados)
        assert "Debe seleccionar un unico proyecto" == rv 
        
    def test_validar_seleccion_candidatos_comite(self):
        seleccionados = []
        rv = managers.solicitud_mgr.\
        validar_seleccion_candidatos_comite(seleccionados)
        assert "Debe seleccionar al menos un usuario" == rv
        
    def test_validar_seleccion_desasignar_comite(self):
        seleccionados = []
        nombre_proyecto = 'p1'
        rv = managers.solicitud_mgr.\
        validar_seleccion_desasignar_comite(nombre_proyecto, \
        seleccionados)
        assert "Debe seleccionar al menos un usuario" == rv
        
    def test_validaciones_boton_votar_solicitud(self):
        seleccionados = []
        nombre_proyecto = 'p1'
        id_usuario = 'id_usuario'
        rv = managers.solicitud_mgr.\
        validaciones_boton_votar_solicitud(seleccionados, id_usuario, \
        nombre_proyecto)
        assert "Debe seleccionar una solicitud" == rv

        seleccionados.append("cadena1")
        seleccionados.append("cadena2")
        rv = managers.solicitud_mgr.\
        validaciones_boton_votar_solicitud(seleccionados, id_usuario, \
        nombre_proyecto)
        assert "Debe seleccionar una unica solicitud" == rv 
    
if __name__ == '__main__':
    unittest.main()
